﻿
/*
 * Javasript base on Functions(JBF)
 * 
 * Copyright(c) 2010, Fooxee (JA86.CN)
 *
 * JBF is licensed under the terms of the Open Source GPL 3.0(http://www.gnu.org/licenses/gpl.html) license. 
 * 
 * JBF's blog: http://www.cnblogs.com/JBF/
 * 
 * Created by Fooxee. at 2010.02.27  mailTo:hjccjun@163.com
 */

var JBF = window.JBF = window.jbf = window.$$=function(selector,context)
{
	if(JBF.Dom && JBF.Dom.fn && JBF.Dom.fn.init)
	{
		return JBF.Dom.fn.init(selector,context);
	}
	else
	{
		//未包含DOM操作
		selector = selector || document;
		if (selector.nodeType) 
		{
			return selector;
		}
		if (typeof(selector)== "string" )
		{
			return document.getElementById(selector);
		}
		else
		{
			return 	selector;
		}
	}
};

//继承
JBF.extend=function(destination, source)
{
	for (var property in source)
	{
		destination[property] = source[property];
	}
	return destination;
};
//成员
JBF.extend(JBF,{
	
	version:'1.02',
	zIndex:1,
	//空函数(已过期)
	emptyFn:function(){},
	//空函数
	fn:function(){},
	//创建新类
	createClass:function()
	{
		return function()
		{
			this.init.apply(this, arguments);
		}
	},
	//调用 未完成
	call:function()
	{
		/*var args = arguments,
            method = this;
        return function() {
            return method.apply(window, args);
        };
		var method = arguments[0];
		for(var i=0;i<arguments.length-1;i++)
		{
			arguments[i+1]=arguments[i+2];
		}
		//alert(arguments[1])
		method.apply(this,arguments);*/
		throw ('JBF.call:操作未执行');
	},
	//邦定
	bind:function(object, fun)
	{
		return function()
		{
			return fun.apply(object, arguments);
		}
	},
	//列举
	each:function(list, fun)
	{
		var i=0;
		for(var v in list)
		{
			fun(v,i++,list);
		}
	},
	//dom准备
	ready:function(handler)
	{
		if(JBF.Dom && JBF.Dom.ready)
		{
			JBF.Dom.ready(handler);	
		}
		else
		{
			handler();	
		}
	},
	//字符串长度
	len:function(str)
	{
		var i,sum;
		sum=0;
		for(i=0;i<str.length;i++)
		{
			if ((str.charCodeAt(i)>=0) && (str.charCodeAt(i)<=255))
			{
				sum=sum+1;
			}
			else
			{
				sum=sum+2;
			}
		}
		return sum;
	},
	//转换为json对象
	toJson:function(s)
	{
		return eval('('+s+')');
	},
	regTest:function(s,m)
	{
		return m.test(s);
	},
	//是否为空(已过时)
	/**
	 * Returns true if the passed value is a JavaScript array, otherwise false.
	 * <pre></pre>
	 * @param {Mixed} value The value to test
	 * @return {Boolean}
	 */
	isNull:function(chkVal)
	{
		if(chkVal==null || chkVal=="")
		{
			return true;	
		}
		return false;
	},
	isEmpty : function(v, allowBlank)
	{
		return v === null || v === undefined || ((JBF.isArray(v) && !v.length)) || (!allowBlank ? v === '' : false);
	},
	/**
	 * True if the detected browser is Opera.
	 * @type Boolean
	 */
	isArray : function(v)
	{
		return toString.apply(v) === '[object Array]';
	},
	//是否布尔值
	isBool:function(v)
	{
		return (v===true || v===false);
	},
	//是否函数(已过时)
	isFun:function(v)
	{
		return (typeof(v)=='function');
	},
	//是否函数
	isFn:function(v)
	{
		return (typeof(v)=='function');
	},
	//是否对象(已过时)
	isObj:function(chkVal)
	{
		return (typeof(chkVal)=='object');
	},
	//是否对象
	isObject:function(v)
	{
		return (typeof(v)=='object');
	},
	//是否日期
	isDate:function(v)
	{
		return (Object.prototype.toString.call(v)=='[object Date]')
	},
	//是否是email
	isEmail:function(chkVal)
	{
		var reg = /^([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/;
		return reg.test(chkVal);
	},
	//是否是email
	isNumber:function(chkVal)
	{
		var reg = /^([0-9])$/;
		return reg.test(chkVal);
	},
	isDom:function(node)
	{
		return node.nodeType?true:false;
	}
		   
});




//日期操作相关
JBF.Date=JBF.date={
	
	//添加天数
	addDays:function(rDate,d)
	{
		rDate.setDate(rDate.getDate() + d);
		return rDate;
	},
	//添加周
	addWeeks:function(rDate,w)
	{
		rDate.addDays(w * 7);
		return rDate;
	},
	//添加月
	addMonths:function(rDate,m)
	{
		var d = rDate.getDate();
		rDate.setMonth(rDate.getMonth() + m);
	
		if (rDate.getDate() < d)
		{
			rDate.setDate(0);
		}
		return rDate;
	},
	//添加年
	addYears:function(rDate,y)
	{
		var m = rDate.getMonth();
		rDate.setFullYear(rDate.getFullYear() + y);
	
		if (m < rDate.getMonth()) 
		 {
			rDate.setDate(0);
		 }
		 
		 return rDate;
	},
	//取得指定日期的周一的日期
	getFirstDateOfWeek:function(rDate,offset)
	{
		offset=(offset?offset:0)*7;
		rDate.setDate(rDate.getDate()+1+offset-rDate.getDay());
		return rDate;
	},
	//取得指定日期的周日的日期
	getLastDateOfWeek:function(rDate,offset)
	{
		offset=(offset?offset:0)*7;
		rDate.setDate(rDate.getDate()+7+offset-rDate.getDay());
		return rDate;
	},
	//取得指定月的第一天
	getFirstDateOfMonth:function(year,month,offset)
	{
		offset=offset?offset:0;
		var nd=JBF.Date.addMonths(new Date(year+"/"+month+"/1"),offset);
		var ny=nd.getFullYear();
		var nm=nd.getMonth()+1;
	
		return new Date(ny+"/"+nm+"/1");
	},
	//取得指定月的最后一天
	getLastDateOfMonth:function(year,month,offset)
	{
		offset=offset?offset:0;
		var nd=JBF.Date.addMonths(new Date(year+"/"+month+"/1"),offset);
		var ny=nd.getFullYear();
		var nm=nd.getMonth()+1;
		var nd=new Date(ny,nm,1);
		var ld=(new Date(nd.getTime()-1000*60*60*24)).getDate();
		return new Date(ny+"/"+nm+"/"+ld);
	},
	//取得指定月的季度的第一天
	getFirstDateOfQuarter:function(year,month,offset)
	{
		
		offset=offset?offset:0;
		offset=offset*3;
	
		var nd=JBF.Date.getFirstDateOfMonth(year,month,offset);
		var ny=nd.getFullYear();
		var nm=nd.getMonth()+1;
	
		if(nm>=1 && nm <=3)
		{
			return JBF.Date.getFirstDateOfMonth(ny,1,0);
		}
		else if(nm>=4 && nm <=6)
		{
			return JBF.Date.getFirstDateOfMonth(ny,4,0);
		}
		else if(nm>=7 && nm <=9)
		{
			return JBF.Date.getFirstDateOfMonth(ny,7,0);
		}
		else if(nm>=10 && nm <=12)
		{
			return JBF.Date.getFirstDateOfMonth(ny,10,0);
		}
		
	},
	//取得指定月的季度的最后一天
	getLastDateOfQuarter:function(year,month,offset)
	{
		offset=offset?offset:0;
		offset=offset*3;
	
		var nd=JBF.Date.getFirstDateOfMonth(year,month,offset);
		var ny=nd.getFullYear();
		var nm=nd.getMonth()+1;
		
		if(nm>=1 && nm <=3)
		{
			return JBF.Date.getLastDateOfMonth(ny,3,0);
		}
		else if(nm>=4 && nm <=6)
		{
			return JBF.Date.getLastDateOfMonth(ny,6,0);
		}
		else if(nm>=7 && nm <=9)
		{
			return JBF.Date.getLastDateOfMonth(ny,9,0);
		}
		else if(nm>=10 && nm <=12)
		{
			return JBF.Date.getLastDateOfMonth(ny,12,0);
		}
	}

};

(function(){
var ua = navigator.userAgent.toLowerCase(),
check = function(r)
{
	return r.test(ua);
},

isOpera = check(/opera/),
isChrome = check(/chrome/),
isWebKit = check(/webkit/),

isSafari = !isChrome && check(/safari/),
isSafari2 = isSafari && check(/applewebkit\/4/),
isSafari3 = isSafari && check(/version\/3/),
isSafari4 = isSafari && check(/version\/4/),
/*isMaxthon=function()
{
	try{window.external.max_version;isIE=false;return true;}catch(e){return false;}
}(),*/
isIE = !isOpera && check(/msie/),
isIE7 = isIE && check(/msie 7/),
isIE8 = isIE && check(/msie 8/),
isIE6 = isIE && !isIE7 && !isIE8,
isGecko = !isWebKit && check(/gecko/),
isGecko2 = isGecko && check(/rv:1\.8/),
isGecko3 = isGecko && check(/rv:1\.9/),
isFF = isGecko && check(/firefox/),
isFF2 = isFF && check(/firefox\/2/),
isFF3 = isFF && check(/firefox\/3/),


isWindows = check(/windows|win32/),
isMac = check(/macintosh|mac os x/),
isAir = check(/adobeair/),
isLinux = check(/linux/);

JBF.Bwr=JBF.bwr=JBF.Browser=JBF.browser=JBF.extend(JBF,{

	isOpera : isOpera,
	isChrome : isChrome,
	isWebKit : isWebKit,
	//isMaxthon:isMaxthon,
	
	isSafari : isSafari,
	isSafari2 : isSafari2,
	isSafari3 : isSafari3,
	isSafari4 : isSafari4,
	
	isIE : isIE,
	isIE6 : isIE6,
	isIE7 : isIE7,
	isIE8 : isIE8,
	
	isGecko : isGecko,
	isGecko2 : isGecko2,
	isGecko3 : isGecko3,
	isFF : isFF,
	isFF2 : isFF2,
	isFF3 : isFF3,


	isWindows : isWindows,
	isMac : isMac,
	isAir : isAir,
	isLinux : isLinux,
	
	//取得浏览器类型
	getType:function()
	{
		if(isSafari)
		{
			return 'safari';
		}
		else if(isOpera)
		{
			return 'opera';
		}
		else if(isIE)
		{
			return 'msie';
		}
		/*if(isMaxthon)
		{
			return 'maxthon';	
		}*/
		else if(isFF)
		{
			return 'firefox';
		}
		else if(isGecko)
		{
			return 'gecko';
		}
		else
		{
			return 'unknown';
		}
	},
	//取得浏览器版本号
	getVersion:function()
	{
		if(isFF)
		{
			return (ua.match( /.+(?:firefox)[\/ ]([\d.]+)/ ) || [])[1];
		}
		/*else if(!isIE && isMaxthon)
		{
			return window.external.max_version;//.substr(0,1);
		}*/
		return (ua.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1];
	},
	//取得浏览器语言
	getLang:function()
	{
		var lang=navigator.language||navigator.userLanguage;
		lang=JBF.isNull(lang)?'unknown':lang;
		if (lang.indexOf('en') > -1)//english
		{
			return 'en';
		}
		else if (lang.indexOf('fr') > -1)//french
		{
			return 'fr';
		}
		else if (lang.indexOf('de') > -1)//german
		{
			return 'de';
		}
		else if (lang.indexOf('ja') > -1)//japanese
		{
			return 'ja';
		}
		else if (lang.indexOf('zh') > -1)//chinese
		{
			return 'zh';
		}
		else
		{
			return lang;
		}

	}
});


})();

//DOM相关操作
JBF.Dom=JBF.dom=function(selector,context)
{
	return JBF.Dom.fn.init(selector,context);
};

JBF.Dom.fn={
	init:function(selector,context)
	{
		selector = selector || document;
		if (selector.nodeType) 
		{
			this[0] = selector;
			this.el=this[0];
			this.length = 1;
			return this;
		}
		if (typeof selector == "string" )
		{
			return JBF.Dom(document.getElementById(selector));
		}
		else
		{
			alert('dom error');
		}
	},
	offset:function(rel)
	{
		var left = 0, top = 0, elem = rel||this.el;
		
		left=elem.offsetParent ? elem.offsetLeft +elem.offsetParent.offsetLeft  : elem.offsetLeft;
		top =elem.offsetParent ? elem.offsetTop + elem.offsetParent.offsetTop : elem.offsetTop;
		return {top:top,left:left};
	},
	
	hide:function()
	{
		var oldDis=this.el.style.display;
		this.setAttrs({jbf_old_display:JBF.isNull(oldDis)?'':oldDis});
		this.el.style.display='none';
	},
	
	show:function()
	{
		var oldDis=this.getAttr('jbf_old_display');
		if(JBF.isNull(oldDis))
		{
			this.el.style.display='';
		}
		else
		{
			this.el.style.display=(oldDis=='none'?'':oldDis);
			this.removeAttr('jbf_old_display');
		}
	},
	
	//设置属性
	setAttrs:function(ops)
	{
		ops=JBF.isObj(ops)?ops:{};
		var pel=this.el;
		JBF.each(ops,function(p,idx)
		{
			pel.setAttribute(p,ops[p]);
		});
	},
	//取得属性值
	getAttr:function(attrName)
	{
		if(JBF.isNull(attrName))
		{
			return null;	
		}
		return this.el.getAttribute(attrName);
		//return eval('this.el.'+attrName);
	},
	//移除属性
	removeAttr:function(attrName)
	{
		if(JBF.isNull(attrName))
		{
			return;	
		}
		this.el.removeAttribute(attrName);
	},
	
	/*名称:为DOM注册事件.
		参数:
			el			dom元素
			evtName		事件名
			evtHandler	句柄函数
			useCapture	是否使用捕获
		返回:无
	*/
	addListeners:function(listeners,capture)
	{
		listeners=JBF.isObject(listeners)?listeners:{};
		var thisEl=this.el;
		JBF.each(listeners,function(v,i,list)
		{
			var handler=JBF.isFun(list[v])?list[v]:JBF.emptyFn;
			if (thisEl.attachEvent)
			{
				eval('thisEl.on'+v+'=handler');
			}
			else if(thisEl.addEventListener)
			{
				thisEl.addEventListener(v, handler, !JBF.isBool(capture)?false:capture);
			}
			else 
			{
				alert("事件注册失败:注册函数不被所在浏览器所支持!");
			}
			
		});
	},
	on:function(evtname, handler,capture)
	{
		eval('this.addListeners({'+evtname+':handler},capture)');
	},
	//设置或获取el的className
	css:function(clsName)
	{
		var pt=typeof(clsName);
		if(pt=='string' || pt=='number')
		{
			this.el.className=clsName;
		}
		else
		{
			return this.el.className;
		}
	},
	//设置或获取el的html
	html:function(innerHtml)
	{
		var pt=typeof(innerHtml);
		if(pt=='string' || pt=='number' || pt=='boolean')
		{
			this.el.innerHTML=innerHtml;
		}
		else
		{
			return this.el.innerHTML;
		}
	},
	wrap:function()
	{
		
	},
	//设置或获取el的值
	val:function(val)
	{
		var pt=typeof(val);
		if(pt=='string' || pt=='number' || pt=='boolean')
		{
			this.el.value=val;
		}
		else
		{
			return this.el.value;	
		}
	},
	focus:function()
	{
		this.el.focus();
	},
	//设置或获取text的值
	//元素element 1 
	//属性attr 2 
	//文本text 3 
	//注释comments 8 
	//文档document 9 
	text:function(val)
	{
		if(this.el.nodeType!=3)
		{
			return;	
		}
		var pt=typeof(val);
		if(pt=='string' || pt=='number' || pt=='boolean')
		{
			this.el.nodeValue=val;
		}
		else
		{
			return this.el.nodeValue;	
		}
	},
	drag:function()
	{
		//TODO
	},
	
	drop:function()
	{
		//TODO
	},
	
	autoTestPwdStrength:function(outResultDivId,minPwdLen)
	{
		var pwd=this.val();
		var strength = 0;
		minPwdLen=JBF.isNumber(minPwdLen)?minPwdLen:6;
		if (pwd.length<minPwdLen && pwd.length>1)
		{
			strength = 1;
		}
		else
		{
			strength = ((pwd.search(/[a-zA-Z]/)!=-1) ? 1 : 0) + ((pwd.search(/[0-9]/)!=-1) ? 1 : 0) + ((pwd.search(/[^A-Za-z0-9_]/)!=-1) ? 1 : 0);
		}
		
		if(!JBF.isNull(outResultDivId) && JBF.isObject(JBF.Dom(outResultDivId)))
		{
			var spanCss="border:1px solid #ccc;color:#999; border-right:none; padding:2px 10px 0px 10px; margin:0px; float:left;",current="background:#E3F1B8 none repeat scroll 0 0;font-weight:bold;";
			var levL=spanCss+(strength==1?current:''),
				levM=spanCss+(strength==2?current:''),
				levH=spanCss+'border:1px solid #ccc;color:#999;'+(strength==3?current:'');
			var html='<span style="margin:0px; padding:0px;">';
			html+='<span style="'+levL+'">低</span><span style="'+levM+'">中</span>';
			html+='<span style="'+levH+'">高</span>';
			html+='</span>';
			JBF.Dom(outResultDivId).html(html);
		}
		return strength;
	},
	
	//公开属性
	isReady:false,
	handlerCache:[],
	timer:null,
	//公开方法
	ready:function(handler)
	{
		JBF.Dom.fn.pollReady();
		if(JBF.Dom.fn.isReady)
		{
			handler();
		}
		else
		{
			if(JBF.isFn(handler))
			{
				JBF.Dom.fn.handlerCache.push(handler);	
			}
		}
	},
	fire:function()
	{
		JBF.Dom.fn.isReady=true;
		JBF.each(JBF.Dom.fn.handlerCache,function(v,i,list)
		{
			var h=list[v];
			h.call(window);
		});
		if (JBF.Dom.fn.timer){window.clearTimeout(JBF.Dom.fn.timer);}
	},
	pollReady:function()
	{
		if(arguments.callee.one) return;
		arguments.callee.one = true;
		var fire=this.fire;
		if (!+"\v1")//IE
		{
			if (self === self.top)
			{
				(function()
				{
					if (JBF.Dom.fn.isReady) return;
					try
					{document.documentElement.doScroll("left");} catch(e)
					{
						JBF.Dom.fn.timer=setTimeout(arguments.callee,0);
						return;
					}
					JBF.Dom.fn.ready();
				})();
				document.onreadystatechange = function()
				{
					if (document.readyState === 'complete')
					{
						document.onreadystatechange = null;//清除加载函数
						fire();
					}
				};
			}
		}
		else
		{
			document.addEventListener("DOMContentLoaded", function()
			{
				document.removeEventListener( "DOMContentLoaded", arguments.callee, false );//清除加载函数
				fire();
			}, false);
		}
	}
};
JBF.Dom.ready=JBF.Dom.fn.ready;

/**
 * JBF的底层Ajax实现方法.
 * 
 * <pre></pre>
 * @参数 {Object} Ajax配置项
 * <li>url			{String} 发送请求的地址。</li>
 * <li>method		{String} (默认: "GET") 请求方式 ("POST" 或 "GET")， 默认为 "GET"。</li>
 * <li>async		{Boolean} (默认: true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为 false。注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行。</li>
 * <li>cache		{Boolean} (默认: true) 设置为 false 将不会从浏览器缓存中加载请求信息。</li>
 * <li>beforeSend	{Function} 发送请求前可修改 XMLHttpRequest 对象的函数，如添加自定义 HTTP 头。XMLHttpRequest对象是唯一的参数。</li>
 * <li>callback		{Function} 请求成功后回调函数。这个方法有两个参数：服务器返回数据、XMLHttpRequest对象
	function (data, XMLHttpRequest)
	{
		//TODO
	}
	</li>
 * <li>complete		{Function} 请求完成后回调函数 (请求成功或失败时均调用)。参数： XMLHttpRequest对象，返回状态
 	function (XMLHttpRequest,status)
	{
		//TODO
	}
	</li>
 * <li>error		{Function} 请求失败时将调用此方法。这个方法有三个参数：返回状态,状态文本,XMLHttpRequest对象。
 	function (status,statusText,XMLHttpRequest)
	{
		//TODO
	}
	</li>
 * <li>params	{Object} 发送到服务器的数据。必须为 Key/Value 格式。</li>
 * <li></li>
 * @返回 {Boolean}
 */
JBF.Ajax=JBF.ajax=function(options)
{
	options=options?options:{};
	
	//请求方式
	options.method=(options.method=='GET' || options.method=='POST')?options.method:'GET';
	//是否异步请求
	options.async=(options.async===true || options.async===false)?options.async:true;
	//是否缓存
	options.cache=(options.cache===true || options.cache===false)?options.cache:false;
	
	//回调方法
	options.callback=JBF.isFun(options.callback)?options.callback:JBF.emptyFn;
	//请求发送前
	options.beforeSend=JBF.isFun(options.beforeSend)?options.beforeSend:JBF.emptyFn;
	//请求完成后
	options.complete=JBF.isFun(options.complete)?options.complete:JBF.emptyFn;
	//请求错误时
	options.error=JBF.isFun(options.error)?options.error:JBF.emptyFn;
	
	//请求参数
	options.params=JBF.isObj(options.params)?options.params:null;
	
	if(!options.cache)
	{
		options.params.timespace=new Date().getTime();
	}
	
	//构造参数
	var PostParams=function()
	{
		var tempArr = new Array();
		JBF.each(options.params,function(p,idx)
		{
			tempArr.push(p + "=" + options.params[p]);
		});
		return tempArr.join("&");
	}();
	
	if(options.method=='GET')
	{
		if(options.url.indexOf('?')>3)
		{
			options.url +='&'+PostParams;
		}
		else
		{
			options.url +='?'+PostParams;
		}
	}
	
	var httpRequest=(function()
	{
        try {return new ActiveXObject("Microsoft.XMLHTTP");}
        catch(e) {try {return new ActiveXObject("Msxml2.XMLHTTP");}
        catch(e) {try {return new XMLHttpRequest();}catch(e) {return window.createRequest();};};};
	})();
	var pollHandler;
	var stateChgHandler=function()
	{
		if(httpRequest.readyState==4)
		{
			if(httpRequest.status==200)
			{
				options.callback(httpRequest.responseText||httpRequest.responseXml,httpRequest);
			}
			else //http 状态错误 返回 状态,状态文本,request对象
			{
				options.error(httpRequest.status,httpRequest.statusText,httpRequest);
			}
			options.complete(httpRequest.status,httpRequest);
			clearTimeout(pollHandler);
		}
	};
	
	//httpRequest.setRequestHeader("Content-Type","text/xml"); 
	options.beforeSend(httpRequest);
	httpRequest.open(options.method,options.url,options.async);
	//ie
	if(!+"\v1")
	{
		httpRequest.onreadystatechange=stateChgHandler;
	}
	if(PostParams)
	{
        httpRequest.setRequestHeader("Content-Length", PostParams.length);   
        httpRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded;");
    };
	httpRequest.send(options.method=='GET'?null:PostParams);
	
	//ff
	if(!!+"\v1")
	{
		httpRequest.onreadystatechange=stateChgHandler();
		//异步为真时
		if(options.async)
		{
			pollHandler=setTimeout(function()
			{
				stateChgHandler();
			},0);
		}
	}
	
	
};
JBF.extend(JBF.Ajax,{
	
	/**
	 * POST方式来进行Ajax请求
	 * @参数 {String} 发送请求的地址。
	 * @参数 {Object} 发送到服务器的数据。必须为 Key/Value 格式。
	 * @参数 {Function} 请求成功后回调函数。这个方法有两个参数：服务器返回数据、XMLHttpRequest对象
	 * @参数 {Boolean} (默认: true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为 false。注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行。
	 * @参数 {Boolean} (默认: true) 设置为 false 将不会从浏览器缓存中加载请求信息。
	 * @返回 {Void}
	 */
	post:function(url,params,callback,async,cache)
	{
		return 	JBF.Ajax({url:url,params:params,callback:callback,method:'POST',async:async,cache:cache});
	},
	/**
	 * GET方式来进行Ajax请求
	 * @参数 {String} 发送请求的地址。
	 * @参数 {Object} 发送到服务器的数据。必须为 Key/Value 格式。
	 * @参数 {Function} 请求成功后回调函数。这个方法有两个参数：服务器返回数据、XMLHttpRequest对象
	 * @参数 {Boolean} (默认: true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为 false。注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行。
	 * @参数 {Boolean} (默认: true) 设置为 false 将不会从浏览器缓存中加载请求信息。
	 * @返回 {Void}
	 */
	get:function(url,params,callback,async,cache)
	{
		return 	JBF.Ajax({url:url,params:params,callback:callback,method:'GET',async:async,cache:cache});
	},
	/**
	 * POST方式来进行Ajax请求,并对返回数据进行JSON反序列操作，如果失败侧返回原数据。
	 * @参数 {String} 发送请求的地址。
	 * @参数 {Object} 发送到服务器的数据。必须为 Key/Value 格式。
	 * @参数 {Function} 请求成功后回调函数。这个方法有两个参数：服务器返回数据、XMLHttpRequest对象
	 * @参数 {Boolean} (默认: true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为 false。注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行。
	 * @参数 {Boolean} (默认: true) 设置为 false 将不会从浏览器缓存中加载请求信息。
	 * @返回 {Void}
	 */
	postJSON:function(url,params,callback,async,cache)
	{
		this.post(url,params,function(rspText,httpRequest)
		{
			try
			{
				callback(JBF.toJson(rspText),httpRequest);
			}
			catch(e)
			{
				callback(rspText,httpRequest);	
			}
		},async);
	},
	/**
	 * GET方式来进行Ajax请求,并对返回数据进行JSON反序列操作，如果失败侧返回原数据。
	 * @参数 {String} 发送请求的地址。
	 * @参数 {Object} 发送到服务器的数据。必须为 Key/Value 格式。
	 * @参数 {Function} 请求成功后回调函数。这个方法有两个参数：服务器返回数据、XMLHttpRequest对象
	 * @参数 {Boolean} (默认: true) 默认设置下，所有请求均为异步请求。如果需要发送同步请求，请将此选项设置为 false。注意，同步请求将锁住浏览器，用户其它操作必须等待请求完成才可以执行。
	 * @参数 {Boolean} (默认: true) 设置为 false 将不会从浏览器缓存中加载请求信息。
	 * @返回 {Void}
	 */
	getJSON:function(url,params,callback,async,cache)
	{
		this.get(url,params,function(rspText,httpRequest)
		{
			try
			{
				callback(JBF.toJson(rspText),httpRequest);
			}
			catch(e)
			{
				callback(rspText,httpRequest);	
			}
		},async);
	}
});

//Cookie操作
JBF.Cookie=JBF.cookie={
	
	//设置
	set:function(sName, sValue, iHour)
	{
		var sCookie = sName + "=" + encodeURIComponent(sValue);
		if (iHour)
		{
			var oExpires = new Date( new Date().getTime() + iHour * 3600000);
			sCookie += "; expires=" + oExpires.toGMTString();
		}
		document.cookie = sCookie;
	},
	//获取
	get:function(sName)
	{
		var sRE = "(?:; )?" + sName + "=([^;]*);?";
		var oRE = new RegExp(sRE);
		if (oRE.test(document.cookie))
		{
			return decodeURIComponent(RegExp["$1"]);
		} 
		else
		{
			return null;
		}
	},
	//移除
	remove:function(sName)
	{
		this.set(sName,null,-9999);
	},
	//清除所有Cookie
	clear:function()
	{
		document.cookie=null;
	}
};
